package com.qyx.pmpucat.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import com.mybatisflex.core.query.QueryWrapper;
import com.qyx.pmpucat.common.exception.ClientException;
import com.qyx.pmpucat.entity.Question;
import com.qyx.pmpucat.entity.Questionnaire;
import com.qyx.pmpucat.entity.QuestionnaireGroup;
import com.qyx.pmpucat.mapper.QuestionMapper;
import com.qyx.pmpucat.mapper.QuestionnaireGroupMapper;
import com.qyx.pmpucat.mapper.QuestionnaireMapper;
import com.qyx.pmpucat.service.QuestionnaireGroupService;
import com.qyx.pmpucat.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.List;

// 导入表定义常量类
import static com.qyx.pmpucat.entity.table.QuestionnaireTableDef.QUESTIONNAIRE;
import static com.qyx.pmpucat.entity.table.QuestionTableDef.QUESTION;

/**
 * 问卷组服务实现
 */
@Service
@RequiredArgsConstructor
public class QuestionnaireGroupServiceImpl implements QuestionnaireGroupService {

    private final QuestionnaireGroupMapper questionnaireGroupMapper;
    private final QuestionnaireMapper questionnaireMapper;
    private final QuestionMapper questionMapper;
    private final UserService userService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createQuestionnaireGroup(QuestionnaireGroup questionnaireGroup) {
        // 验证问卷ID列表
        validateQuestionnaireIds(questionnaireGroup.getQuestionnaireIds());
        
        // 设置问卷组状态为未发布
        questionnaireGroup.setStatus(0);
        // 设置创建人信息
        Long userId = StpUtil.getLoginIdAsLong();
        questionnaireGroup.setCreateBy(userId);
        questionnaireGroup.setCreateUser(userService.getById(userId).getUsername());
        
        // 保存问卷组
        questionnaireGroupMapper.insert(questionnaireGroup);
        
        return questionnaireGroup.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateQuestionnaireGroup(QuestionnaireGroup questionnaireGroup) {
        // 检查问卷组是否存在
        Long questionnaireGroupId = questionnaireGroup.getId();
        if (questionnaireGroupId == null) {
            throw new ClientException("问卷组ID不能为空");
        }
        
        QuestionnaireGroup existGroup = questionnaireGroupMapper.selectOneById(questionnaireGroupId);
        if (existGroup == null) {
            throw new ClientException("问卷组不存在");
        }
        
        // 已发布的问卷组不能修改
        if (existGroup.getStatus() == 1) {
            throw new ClientException("已发布的问卷组不能修改");
        }
        
        // 验证问卷ID列表
        if (questionnaireGroup.getQuestionnaireIds() != null) {
            validateQuestionnaireIds(questionnaireGroup.getQuestionnaireIds());
        }
        
        // 更新问卷组信息
        questionnaireGroupMapper.update(questionnaireGroup);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteQuestionnaireGroup(Long id) {
        // 检查问卷组是否存在
        QuestionnaireGroup existGroup = questionnaireGroupMapper.selectOneById(id);
        if (existGroup == null) {
            throw new ClientException("问卷组不存在");
        }
        
        // 已发布的问卷组不能删除
        if (existGroup.getStatus() == 1) {
            throw new ClientException("已发布的问卷组不能删除");
        }
        
        // 删除问卷组
        questionnaireGroupMapper.deleteById(id);
    }

    @Override
    public QuestionnaireGroup getQuestionnaireGroupDetail(Long id) {
        // 检查问卷组是否存在
        QuestionnaireGroup questionnaireGroup = questionnaireGroupMapper.selectOneById(id);
        if (questionnaireGroup == null) {
            throw new ClientException("问卷组不存在");
        }
        
        return questionnaireGroup;
    }

    @Override
    public List<QuestionnaireGroup> getQuestionnaireGroupList(String title, Integer status) {
        // 构建查询条件
        QueryWrapper queryWrapper = QueryWrapper.create();
        
        // 标题模糊查询
        if (StringUtils.hasText(title)) {
            queryWrapper.where("title like ?", "%" + title + "%");
        }
        
        // 状态查询
        if (status != null) {
            queryWrapper.where("status = ?", status);
        }
        
        // 按创建时间倒序排列
        queryWrapper.orderBy("create_time desc");
        
        return questionnaireGroupMapper.selectListByQuery(queryWrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void publishQuestionnaireGroup(Long id) {
        // 检查问卷组是否存在
        QuestionnaireGroup existGroup = questionnaireGroupMapper.selectOneById(id);
        if (existGroup == null) {
            throw new ClientException("问卷组不存在");
        }
        
        // 已发布的问卷组不能重复发布
        if (existGroup.getStatus() == 1) {
            throw new ClientException("问卷组已发布");
        }
        
        // 检查问卷组是否有问卷
        if (existGroup.getQuestionnaireIds() == null || existGroup.getQuestionnaireIds().isEmpty()) {
            throw new ClientException("问卷组至少需要包含一个问卷");
        }
        
        // 验证所有问卷都存在且有问题
        validateQuestionnaireIds(existGroup.getQuestionnaireIds());
        
        // 发布问卷组
        existGroup.setStatus(1);
        questionnaireGroupMapper.update(existGroup);
        
        // 同时发布关联的所有问卷
        for (Long questionnaireId : existGroup.getQuestionnaireIds()) {
            Questionnaire questionnaire = questionnaireMapper.selectOneById(questionnaireId);
            if (questionnaire != null && questionnaire.getStatus() != 1) {
                questionnaire.setStatus(1);
                questionnaireMapper.update(questionnaire);
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void offlineQuestionnaireGroup(Long id) {
        // 检查问卷组是否存在
        QuestionnaireGroup existGroup = questionnaireGroupMapper.selectOneById(id);
        if (existGroup == null) {
            throw new ClientException("问卷组不存在");
        }
        
        // 未发布的问卷组不能下线
        if (existGroup.getStatus() != 1) {
            throw new ClientException("问卷组未发布");
        }
        
        // 下线问卷组
        existGroup.setStatus(2);
        questionnaireGroupMapper.update(existGroup);
        
        // 同时下线关联的所有问卷
        for (Long questionnaireId : existGroup.getQuestionnaireIds()) {
            Questionnaire questionnaire = questionnaireMapper.selectOneById(questionnaireId);
            if (questionnaire != null && questionnaire.getStatus() == 1) {
                questionnaire.setStatus(2);
                questionnaireMapper.update(questionnaire);
            }
        }
    }
    
    /**
     * 验证问卷ID列表
     */
    private void validateQuestionnaireIds(List<Long> questionnaireIds) {
        if (questionnaireIds == null || questionnaireIds.isEmpty()) {
            throw new ClientException("问卷组至少需要包含一个问卷");
        }
        
        for (Long questionnaireId : questionnaireIds) {
            // 检查问卷是否存在
            Questionnaire questionnaire = questionnaireMapper.selectOneById(questionnaireId);
            if (questionnaire == null) {
                throw new ClientException("问卷ID[" + questionnaireId + "]不存在");
            }
            
            // 检查问卷是否有问题
            QueryWrapper questionWrapper = QueryWrapper.create();
            questionWrapper.where(QUESTION.QUESTIONNAIRE_ID.eq(questionnaireId));
            long questionCount = questionMapper.selectCountByQuery(questionWrapper);
            if (questionCount == 0) {
                throw new ClientException("问卷[" + questionnaire.getTitle() + "]至少需要一个问题");
            }
            
            // 检查所有问题是否都有选项
            List<Question> questions = questionMapper.selectListByQuery(questionWrapper);
            for (Question question : questions) {
                if (question.getOptions() == null || question.getOptions().isEmpty()) {
                    throw new ClientException("问卷[" + questionnaire.getTitle() + "]中的问题[" + question.getTitle() + "]至少需要一个选项");
                }
            }
        }
    }
} 